import pytest  # used for our unit tests
# Import the real classes from the module under test.
# We import TreeSitterAnalyzer (the class under test) and ExportInfo (the domain object used by the method).
from codeflash.languages.javascript.treesitter_utils import (
    ExportInfo, TreeSitterAnalyzer)

# Helper to create an ExportInfo instance without relying on its constructor signature.
# We use object.__new__ to create a real instance of ExportInfo (satisfies "real instances" rule)
# and then set the attributes that TreeSitterAnalyzer.is_function_exported reads:
#   - default_export (str | None)
#   - exported_names (list[tuple[str, str | None]])
def make_export_info(default_export, exported_names):
    ei = object.__new__(ExportInfo)  # create a raw instance of the real ExportInfo class
    # set required attributes directly; the analyzer accesses these attributes, so that's sufficient
    setattr(ei, "default_export", default_export)
    setattr(ei, "exported_names", exported_names)
    return ei

def test_named_export_returns_true_and_name():
    # Create analyzer instance with a non-string language (constructor will accept it as-is).
    analyzer = TreeSitterAnalyzer(language=object())
    # Prepare a single ExportInfo indicating a named export "foo" with no alias.
    export = make_export_info(default_export=None, exported_names=[("foo", None)])
    # Override the instance's find_exports to return our controlled export list.
    analyzer.find_exports = lambda source: [export]
    # The function "foo" should be detected as exported and its export name should be "foo".
    codeflash_output = analyzer.is_function_exported("dummy source", "foo") # 1.46μs -> 1.34μs (9.02% faster)

def test_named_export_with_alias_returns_alias():
    analyzer = TreeSitterAnalyzer(language=object())
    # Named export where original name is "orig" but exported as "alias".
    export = make_export_info(default_export=None, exported_names=[("orig", "alias")])
    analyzer.find_exports = lambda source: [export]
    # Query by original name "orig" should return the alias.
    codeflash_output = analyzer.is_function_exported("s", "orig") # 1.36μs -> 1.19μs (14.3% faster)

def test_default_export_matches_function_name_returns_default_marker():
    analyzer = TreeSitterAnalyzer(language=object())
    # Default export set to "mainFunc"
    export = make_export_info(default_export="mainFunc", exported_names=[])
    analyzer.find_exports = lambda source: [export]
    # When function_name matches default_export, the method should return (True, "default")
    codeflash_output = analyzer.is_function_exported("s", "mainFunc") # 972ns -> 961ns (1.14% faster)

def test_function_not_exported_returns_false_none():
    analyzer = TreeSitterAnalyzer(language=object())
    # ExportInfo does not include the queried function.
    export = make_export_info(default_export=None, exported_names=[("other", None)])
    analyzer.find_exports = lambda source: [export]
    # Querying a non-exported function should return (False, None)
    codeflash_output = analyzer.is_function_exported("s", "missing") # 1.17μs -> 1.14μs (2.63% faster)

def test_class_method_detection_when_class_is_default_export():
    analyzer = TreeSitterAnalyzer(language=object())
    # Class "MyClass" is the default export; method "method" itself is not exported directly.
    export = make_export_info(default_export="MyClass", exported_names=[])
    analyzer.find_exports = lambda source: [export]
    # Provide class_name so the analyzer will check class exports; expect True and class name returned.
    codeflash_output = analyzer.is_function_exported("s", "method", class_name="MyClass") # 1.65μs -> 1.58μs (4.42% faster)

def test_class_method_detection_when_class_exported_with_alias():
    analyzer = TreeSitterAnalyzer(language=object())
    # Named export where class "COrig" is exported as "CExport"
    export = make_export_info(default_export=None, exported_names=[("COrig", "CExport")])
    analyzer.find_exports = lambda source: [export]
    # Should detect the class export and return the alias
    codeflash_output = analyzer.is_function_exported("s", "someMethod", class_name="COrig") # 1.79μs -> 1.70μs (5.28% faster)

def test_function_name_with_special_characters():
    analyzer = TreeSitterAnalyzer(language=object())
    # Use a function name with special characters (valid JS identifier parts like $ or _)
    export = make_export_info(default_export=None, exported_names=[("weird$name__", None)])
    analyzer.find_exports = lambda source: [export]
    # The analyzer should match exact names including special characters
    codeflash_output = analyzer.is_function_exported("s", "weird$name__") # 1.24μs -> 1.17μs (5.97% faster)

def test_empty_function_name_and_empty_exports():
    analyzer = TreeSitterAnalyzer(language=object())
    # No exports
    analyzer.find_exports = lambda source: []
    # Querying an empty function name should deterministically return (False, None)
    codeflash_output = analyzer.is_function_exported("s", "") # 902ns -> 802ns (12.5% faster)

def test_multiple_exports_prioritize_direct_function_export_over_class_export():
    analyzer = TreeSitterAnalyzer(language=object())
    # First export lists the function as a named export; second export lists the class as default export.
    export1 = make_export_info(default_export=None, exported_names=[("fn", None)])
    export2 = make_export_info(default_export="MyClass", exported_names=[])
    analyzer.find_exports = lambda source: [export1, export2]
    # Querying function "fn" should return (True, "fn") without needing to consider class exports.
    codeflash_output = analyzer.is_function_exported("s", "fn", class_name="MyClass") # 1.54μs -> 1.40μs (10.1% faster)

def test_named_alias_falsy_but_returns_original_name_when_alias_is_empty_string():
    analyzer = TreeSitterAnalyzer(language=object())
    # Provide alias as empty string; code uses `alias or name` so it should fall back to the original name.
    export = make_export_info(default_export=None, exported_names=[("origName", "")])
    analyzer.find_exports = lambda source: [export]
    codeflash_output = analyzer.is_function_exported("s", "origName") # 1.30μs -> 1.18μs (10.2% faster)

def test_large_number_of_exports_performance_and_correctness():
    analyzer = TreeSitterAnalyzer(language=object())
    exports = []
    # Create 1000 ExportInfo instances where only the last one contains the target function.
    for i in range(1000):
        # Most exports are unrelated named exports.
        exports.append(make_export_info(default_export=None, exported_names=[(f"f{i}", None)]))
    # Append one export that actually contains the function we will query.
    target_export = make_export_info(default_export=None, exported_names=[("targetFn", None)])
    exports.append(target_export)
    # Assign the large export list to the analyzer's find_exports
    analyzer.find_exports = lambda source: exports
    # The analyzer should find "targetFn" among many entries and return quickly with the correct name.
    codeflash_output = analyzer.is_function_exported("s", "targetFn") # 101μs -> 99.9μs (1.93% faster)

def test_repeated_calls_stability_under_many_iterations():
    analyzer = TreeSitterAnalyzer(language=object())
    # Build a medium list of exports and include the function in the middle.
    exports = [make_export_info(default_export=None, exported_names=[(f"a{i}", None)]) for i in range(50)]
    # Insert target at position 25
    exports.insert(25, make_export_info(default_export=None, exported_names=[("repeatFn", None)]))
    analyzer.find_exports = lambda source: exports
    # Call the method 1000 times to check for deterministic behavior and no state leakage
    for _ in range(1000):
        codeflash_output = analyzer.is_function_exported("s", "repeatFn") # 2.72ms -> 2.66ms (2.26% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest
from codeflash.languages.javascript.treesitter_utils import TreeSitterAnalyzer

class TestBasicFunctionality:
    """Test basic expected behavior of is_function_exported."""

    def test_simple_named_export_function(self):
        """Test that a simple named export is correctly identified."""
        source = """
export function myFunction() {
    return 42;
}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "myFunction") # 41.3μs -> 40.3μs (2.46% faster)

    def test_simple_default_export_function(self):
        """Test that a default export function is correctly identified."""
        source = """
export default function myFunction() {
    return 42;
}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "myFunction") # 39.2μs -> 38.0μs (3.06% faster)

    def test_function_not_exported(self):
        """Test that a non-exported function returns False."""
        source = """
function myFunction() {
    return 42;
}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "myFunction") # 26.2μs -> 25.7μs (1.79% faster)

    def test_named_export_with_alias(self):
        """Test that a named export with alias returns the alias."""
        source = """
function myFunction() {
    return 42;
}
export { myFunction as renamedFunction };
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "myFunction") # 44.5μs -> 43.6μs (2.16% faster)

    def test_multiple_named_exports_one_matches(self):
        """Test that when multiple functions are exported, the correct one is identified."""
        source = """
export function funcA() {}
export function funcB() {}
export function funcC() {}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported_a, export_name_a = analyzer.is_function_exported(source, "funcA") # 55.4μs -> 53.5μs (3.48% faster)
        is_exported_b, export_name_b = analyzer.is_function_exported(source, "funcB") # 38.6μs -> 1.14μs (3276% faster)
        is_exported_c, export_name_c = analyzer.is_function_exported(source, "funcC") # 33.6μs -> 771ns (4258% faster)

    def test_class_method_exported_via_class(self):
        """Test that a class method is exported when the class is exported."""
        source = """
export class MyClass {
    myMethod() {
        return 42;
    }
}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(
            source, "myMethod", class_name="MyClass"
        ) # 42.7μs -> 41.6μs (2.75% faster)

    def test_class_not_exported_so_method_not_exported(self):
        """Test that when a class is not exported, its methods are not exported."""
        source = """
class MyClass {
    myMethod() {
        return 42;
    }
}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(
            source, "myMethod", class_name="MyClass"
        ) # 31.7μs -> 31.2μs (1.61% faster)

    def test_function_name_case_sensitive(self):
        """Test that function name matching is case-sensitive."""
        source = """
export function myFunction() {
    return 42;
}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "MyFunction") # 34.8μs -> 34.3μs (1.55% faster)

    def test_default_export_class_with_method(self):
        """Test that a method of a default-exported class is considered exported."""
        source = """
export default class MyClass {
    myMethod() {
        return 42;
    }
}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(
            source, "myMethod", class_name="MyClass"
        ) # 42.4μs -> 42.1μs (0.689% faster)

class TestEdgeCases:
    """Test edge cases and boundary conditions."""

    def test_empty_source_code(self):
        """Test behavior with empty source code."""
        source = ""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "myFunction") # 9.27μs -> 9.11μs (1.76% faster)

    def test_empty_function_name(self):
        """Test behavior when searching for a function with empty name."""
        source = """
export function myFunction() {
    return 42;
}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "") # 35.5μs -> 34.6μs (2.52% faster)

    def test_nonexistent_function_in_exports(self):
        """Test behavior when searching for a function that doesn't exist."""
        source = """
export function myFunction() {
    return 42;
}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "nonexistent") # 34.3μs -> 33.7μs (1.87% faster)

    def test_class_name_none_with_function_export(self):
        """Test that class_name=None doesn't affect standalone function exports."""
        source = """
export function myFunction() {
    return 42;
}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(
            source, "myFunction", class_name=None
        ) # 34.3μs -> 33.2μs (3.23% faster)

    def test_function_name_with_special_characters(self):
        """Test function names with underscores and numbers."""
        source = """
export function my_Function_123() {
    return 42;
}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "my_Function_123") # 34.1μs -> 33.2μs (2.81% faster)

    def test_class_name_with_special_characters(self):
        """Test class names with underscores and numbers."""
        source = """
export class My_Class_123 {
    myMethod() {
        return 42;
    }
}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(
            source, "myMethod", class_name="My_Class_123"
        ) # 41.3μs -> 40.3μs (2.43% faster)

    def test_export_statement_with_multiple_aliases(self):
        """Test export statement exporting multiple functions with aliases."""
        source = """
function funcA() {}
function funcB() {}
export { funcA as aliasA, funcB as aliasB };
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported_a, export_name_a = analyzer.is_function_exported(source, "funcA") # 51.6μs -> 50.8μs (1.52% faster)
        is_exported_b, export_name_b = analyzer.is_function_exported(source, "funcB") # 36.9μs -> 972ns (3693% faster)

    def test_function_with_same_name_as_class(self):
        """Test when a function and class have the same name but are separate entities."""
        source = """
function myEntity() { return 1; }
class myEntity {}
export { myEntity };
"""
        analyzer = TreeSitterAnalyzer("javascript")
        # Looking for the function
        is_exported, export_name = analyzer.is_function_exported(source, "myEntity") # 46.6μs -> 45.6μs (2.20% faster)

    def test_whitespace_in_source_code(self):
        """Test that whitespace variations don't affect export detection."""
        source = """

export    function    myFunction   (  )  {
    return 42;
}

"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "myFunction") # 35.3μs -> 34.5μs (2.29% faster)

    def test_comments_in_source_code(self):
        """Test that comments don't interfere with export detection."""
        source = """
// This is a comment
export function myFunction() { // inline comment
    return 42;
}
/* block comment */
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "myFunction") # 38.9μs -> 38.3μs (1.78% faster)

    def test_unicode_function_names(self):
        """Test function names with unicode characters."""
        source = """
export function café() {
    return 42;
}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "café") # 34.9μs -> 34.3μs (1.78% faster)

    def test_nested_class_method(self):
        """Test method of a nested exported class."""
        source = """
export class OuterClass {
    innerMethod() {
        return 42;
    }
}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(
            source, "innerMethod", class_name="OuterClass"
        ) # 41.4μs -> 40.5μs (2.18% faster)

    def test_class_with_empty_class_name_parameter(self):
        """Test when class_name is provided as empty string."""
        source = """
export function myFunction() {
    return 42;
}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "myFunction", class_name="") # 33.6μs -> 33.6μs (0.092% faster)

    def test_mixed_commonjs_and_es_exports(self):
        """Test source with both CommonJS and ES module export statements."""
        source = """
function funcA() { return 1; }
export function funcB() { return 2; }
module.exports = funcA;
"""
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported_a, export_name_a = analyzer.is_function_exported(source, "funcA") # 60.9μs -> 60.0μs (1.47% faster)
        is_exported_b, export_name_b = analyzer.is_function_exported(source, "funcB") # 44.4μs -> 992ns (4377% faster)

    def test_long_source_code(self):
        """Test with a source file containing many lines."""
        lines = ["// Comment line " + str(i) for i in range(100)]
        lines.append("export function myFunction() { return 42; }")
        lines.extend(["// More comments " + str(i) for i in range(100)])
        source = "\n".join(lines)
        
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "myFunction") # 214μs -> 213μs (0.413% faster)

class TestLargeScale:
    """Test performance and scalability with large data."""

    def test_many_exports_find_target(self):
        """Test finding a function among many exported functions."""
        # Create source with 100 exported functions
        source_lines = []
        for i in range(100):
            source_lines.append(f"export function func{i}() {{ return {i}; }}")
        source = "\n".join(source_lines)
        
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "func50") # 1.33ms -> 1.29ms (2.79% faster)

    def test_many_exports_target_not_found(self):
        """Test not finding a function among many exported functions."""
        # Create source with 100 exported functions
        source_lines = []
        for i in range(100):
            source_lines.append(f"export function func{i}() {{ return {i}; }}")
        source = "\n".join(source_lines)
        
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "funcNotFound") # 1.28ms -> 1.26ms (1.88% faster)

    def test_many_classes_with_methods(self):
        """Test finding exported method among many exported classes."""
        # Create source with 50 exported classes
        source_lines = []
        for i in range(50):
            source_lines.append(f"""
export class Class{i} {{
    method{i}() {{
        return {i};
    }}
}}
""")
        source = "\n".join(source_lines)
        
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(
            source, "method25", class_name="Class25"
        ) # 846μs -> 841μs (0.582% faster)

    def test_many_named_exports_with_aliases(self):
        """Test finding function among many named exports with aliases."""
        # Create source with many functions exported with aliases
        source_lines = ["function func0() {}"]
        export_parts = ["func0 as alias0"]
        
        for i in range(1, 100):
            source_lines.append(f"function func{i}() {{}}")
            export_parts.append(f"func{i} as alias{i}")
        
        source_lines.append("export { " + ", ".join(export_parts) + " };")
        source = "\n".join(source_lines)
        
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "func50") # 985μs -> 977μs (0.795% faster)

    def test_deeply_nested_code(self):
        """Test with deeply nested code structures."""
        # Create nested functions/blocks
        source = "export function outer() {\n"
        for i in range(50):
            source += "  " * (i + 1) + "function inner" + str(i) + "() {\n"
        source += "  " * 51 + "return 42;\n"
        for i in range(49, -1, -1):
            source += "  " * (i + 1) + "}\n"
        source += "}\n"
        
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(source, "outer") # 551μs -> 546μs (0.988% faster)

    def test_large_class_with_many_methods(self):
        """Test a large exported class with many methods."""
        source = "export class LargeClass {\n"
        for i in range(100):
            source += f"  method{i}() {{ return {i}; }}\n"
        source += "}\n"
        
        analyzer = TreeSitterAnalyzer("javascript")
        is_exported, export_name = analyzer.is_function_exported(
            source, "method50", class_name="LargeClass"
        ) # 781μs -> 777μs (0.511% faster)

    def test_repeated_calls_same_function(self):
        """Test repeated calls to is_function_exported on the same analyzer."""
        source = """
export function myFunction() {
    return 42;
}
"""
        analyzer = TreeSitterAnalyzer("javascript")
        
        # Call multiple times
        for _ in range(100):
            is_exported, export_name = analyzer.is_function_exported(source, "myFunction") # 1.50ms -> 75.3μs (1887% faster)

    def test_many_different_analyzers(self):
        """Test creating many analyzer instances."""
        source = """
export function myFunction() {
    return 42;
}
"""
        
        # Create multiple analyzers
        for _ in range(50):
            analyzer = TreeSitterAnalyzer("javascript")
            is_exported, export_name = analyzer.is_function_exported(source, "myFunction") # 836μs -> 841μs (0.670% slower)

    def test_alternating_exported_and_non_exported(self):
        """Test source with alternating exported and non-exported functions."""
        source_lines = []
        for i in range(100):
            if i % 2 == 0:
                source_lines.append(f"export function func{i}() {{ return {i}; }}")
            else:
                source_lines.append(f"function func{i}() {{ return {i}; }}")
        source = "\n".join(source_lines)
        
        analyzer = TreeSitterAnalyzer("javascript")
        
        # Check even-numbered functions (exported)
        for i in range(0, 100, 2):
            is_exported, export_name = analyzer.is_function_exported(source, f"func{i}") # 51.5ms -> 1.19ms (4215% faster)
        
        # Check odd-numbered functions (not exported)
        for i in range(1, 100, 2):
            is_exported, export_name = analyzer.is_function_exported(source, f"func{i}") # 51.4ms -> 255μs (20051% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.